home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume2 / languags / app.1 next >
Internet Message Format  |  1988-12-30  |  30KB
  1. Path: wucfua!wucs1!uunet!husc6!mailrus!cornell!uw-beaver!apollo!ulowell!page
  2. From: page@swan.ulowell.edu (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v02i109:  app - assembly preprocessor
  5. Message-ID: <10978@swan.ulowell.edu>
  6. Date: 29 Dec 88 22:52:00 GMT
  7. Organization: University of Lowell, Computer Science Dept.
  8. Lines: 915
  9. Approved: page@swan.ulowell.edu
  10.  
  11. Submitted-by: karl%sugar@uunet.UU.NET (Karl Lehenbauer)
  12. Posting-number: Volume 2, Issue 109
  13. Archive-name: languages/app.1
  14.  
  15. [uuencoded binary included.  ..Bob]
  16.  
  17. #    This is a shell archive.
  18. #    Remove everything above and including the cut line.
  19. #    Then run the rest of the file through sh.
  20. #----cut here-----cut here-----cut here-----cut here----#
  21. #!/bin/sh
  22. # shar:    Shell Archiver
  23. #    Run the following text with /bin/sh to create:
  24. #    README
  25. #    app.c
  26. #    makefile
  27. #    app.uu
  28. # This archive created: Thu Dec 29 17:48:46 1988
  29. cat << \SHAR_EOF > README
  30. A.P.P.    Assembly Pre-Processor
  31. ------------------------------
  32.  
  33. PUBLIC DOMAIN
  34.  
  35. written by Karl Lehenbauer, 12/8/88
  36. with a lot of design input by Peter da Silva
  37.  
  38.  
  39. Disclaimer and Redistribution Information
  40. -----------------------------------------
  41.  
  42. APP is placed freely into the public domain for any use without restriction.
  43. APP comes without warranties, expressed or implied.  This is free software.
  44. We don't have a contract.
  45.  
  46. I'm not asking for money for this, but if you feel compelled to send it 
  47. anyway, it is always appreciated.  Make checks to Hackercorp, 3918 
  48. Panorama, Missouri City, TX  77459
  49.  
  50.  
  51. What it is
  52. ----------
  53.  
  54. APP is a preprocessor for the 68000 assembler that comes with Aztec C for 
  55. the Amiga.  It will probably work with other 68000 assemblers.  APP 
  56. provides structured programming constructs for the assembly language
  57. programmer.  Specifically, APP provides support for IF-THEN-ELSE-ELSEIF-
  58. ENDIF constructs and for DO-WHILE-UNTIL-ENDDO constructs.  
  59.  
  60. Consider the C pseudocode fragment:
  61.  
  62. long a, b;
  63.  
  64.     if (a < 0)
  65.     {
  66.         less_than_zero_stuff();
  67.     }
  68.     else
  69.     {
  70.         not_less_that_zero_stuff();
  71.     }
  72.  
  73. In assembler (or pre-77 FORTRAN, for example) to do the same thing requires 
  74. the creation of two bogus labels, as in:
  75.  
  76.     move.l    _a,d0
  77.     bge        else_part
  78.     jsr        _less_than_zero_stuff
  79.     bra        past_the_else
  80. else_part
  81.     jsr        _not_less_than_zero_stuff
  82. past_the_else
  83.  
  84. When you start nesting these deeply, the code quickly becomes unreadable.
  85. Note also that you have to reverse the sense to branch around the code
  86. you really want to execute.  This makes the code less clear.
  87. If the assembler had structured programming constructs like C, Modula 2,
  88. Forth, etc, the creation of these superfluous labels is unnecessary.
  89. Using APP, the above code fragment can be rewritten:
  90.  
  91.     move.l    _a,d0
  92.     .if    lt
  93.     jsr        _less_than_zero_stuff
  94.     .else
  95.     jsr        _not_less_than_zero_stuff
  96.     .endif
  97.  
  98. To define an "if", enter an opcode of ".if" and an operand of a condition
  99. code that the assembler recognizes as a branch when following behind a 'b',
  100. as in condition codes "le", "lt", "eq", "ne", "gt", "ge" yielding "ble",
  101. "blt", "beq", "bne", "bgt", "bge"  You will have set up the condition
  102. codes before the ".if".
  103.  
  104. For in "if", APP will assemble a conditional branch with the sense reversed,
  105. branching to the matching ".else", ".elseif", or ".endif".  APP will make
  106. up labels and produce the equivalent branching code as above.  I have chosen
  107. to make APP's labels be 'L' followed by an increasing sequential integer
  108. label number.  This was chosen to avoid conflicting with Manx's '.' followed
  109. by the number so you can incrementally "structurize" and test as you hand
  110. optimize the output of cc with "-AT" flags selected.
  111.  
  112. APP also supports a do/enddo construct.  The way it works is ".enddo"
  113. compiles a "branch always" instruction back to the corresponding ".do".
  114. To exit the do/enddo, two constructs are provided.  These are ".while"
  115. and ".until".  ".while" takes a condition code and, if it is true,
  116. execution continues below the while, else a branch past the enddo is
  117. taken.  ".until" in the opposite manner, if the condition code is true
  118. a branch past the enddo is taken otherwise it isn't.  For example,
  119.  
  120.     .do
  121.       ;conditional setup stuff
  122.       .
  123.       .
  124.     .while ne
  125.       ; execution stuff
  126.       .
  127.       .
  128.     .enddo
  129.  
  130. ...will execute code between the do and the enddo until the condition code
  131. at the "while" isn't true anymore.  Multiple .whiles and .untils may be
  132. used and .whiles and .untils may be freely intermixed.
  133.  
  134. Nesting of conditionals is permitted to a depth of 32.  When nesting, I
  135. reccomment indenting your code, as in:
  136.  
  137.     tst.l    d0
  138.     .if gt
  139.         add.l    d0,d1
  140.         cmp.l    #max,d1
  141.         .if gt
  142.             move.l    #max,d1
  143.         .endif
  144.     .endif
  145.  
  146. Setting tab stops at four seems to work well.
  147.  
  148.  
  149. How To Invoke APP
  150. -----------------
  151.  
  152. APP requires that the sources files given to it end in ".app" and that
  153. the .app extension be specified.  APP produces an output file where
  154. the name is the name of your source file with ".asm" as the extension.
  155.  
  156.     app foo.app
  157.  
  158. ...produces foo.asm if app doesn't detect any errors while processing you
  159. .app source.
  160.  
  161.  
  162.  
  163. Integrating with your makefile
  164. ------------------------------
  165.  
  166. If you add the following rules to your makefile and list object files
  167. corresponding to your assembly preprocessor source .app files in your 
  168. make dependencies, make will run APP over your .app files and then
  169. run "as" over the resulting .asm files.
  170.  
  171. .app.o:
  172.     app $*.app
  173.     as $*.asm
  174.  
  175.  
  176. Condition Codes Known by APP 
  177. ----------------------------
  178.  
  179.     The following condition codes may be used APP's .if, .elseif, .while
  180.     and .until statements:
  181.  
  182.     "ne"
  183.     "eq"
  184.     "lt"
  185.     "ge"
  186.     "le"
  187.     "gt"
  188.     "cc"
  189.     "cs"
  190.     "vc"
  191.     "vs"
  192.     "hi"
  193.     "ls"
  194.     "pl"
  195.     "mi"
  196.  
  197. Consult your 68000 Reference Manual if you need to know
  198. what status register bits and states correspond to these 
  199. codes.  They're the standard ones.
  200.  
  201.  
  202. APP Error Messages
  203. ------------------
  204.  
  205. APP does a lot of checking of your APP "dot" statements to insure their
  206. validity.  Specifically, APP insures that all .ifs have matching .endifs,
  207. that all .dos have matching .enddos, that only one .else is specified
  208. inside a .if, that .elseifs are only specified inside .ifs, that .whiles
  209. and .untils are only specified inside a .do and that all "dot" structures
  210. are closed at end of file.  If APP does detect an error, it prints an
  211. error message including the line number and exits.  (It could conceivably
  212. go on, but I have yet to take it this far.)  If APP is pointing to the
  213. last line in the file, the problem is that you didn't close a .if or .do
  214. structure somewhere earlier in the file.
  215.  
  216. If APP exits with an error, it removes the .asm output file so the file
  217. won't confuse make into thinking everything went OK with APP when it really
  218. didn't.
  219.  
  220.  
  221. Enumeration of Variations by Pseudo-Example
  222. -------------------------------------------
  223.  
  224.     .if cc
  225.     .endif
  226.  
  227.     .if cc
  228.     .else
  229.     .endif
  230.  
  231.     .if cc
  232.     .elseif cc
  233.     .endif
  234.  
  235.     .if cc
  236.     .elseif cc
  237.     .elseif cc
  238.     .endif
  239.  
  240.     .do
  241.     .enddo
  242.  
  243.     .do
  244.     .while cc
  245.     .enddo
  246.  
  247.  
  248.     .do
  249.     .until cc
  250.     .enddo
  251.  
  252.  
  253.     .do
  254.     .until cc
  255.     .until cc
  256.     .while cc
  257.     .enddo
  258.  
  259.  
  260. Miscellaneous Notes
  261. -------------------
  262.  
  263. APP conditionals may be nested up to 32 levels deep.  If you need to go
  264. deeper (seven or eight seems like the realistic-use upper limit to me), 
  265. change the MAX_NESTING_LEVELS define in app.c.
  266.  
  267. All the APP constructs must be entered in lower case only, and the condition
  268. codes as well.  It would of course be a simple matter to add support for
  269. upper case, but I have yet to feel compelled to do so.
  270.  
  271. Note that the functions provided by APP could have been done by assembler
  272. macros if the Aztec assembler had supported the ability to expand a macro
  273. with an argument being the *value* of a SET variable, had string variables 
  274. or the ability to concatenate text with a SET variable -- it doesn't.
  275.  
  276. Note also that APP doesn't check condition codes for validity unless their
  277. sense has to be reversed.  It probably should check them, but invalid ones 
  278. won't get past the assembler in any case.
  279.  
  280. APP is so vanilla in its construction that it should run on about any
  281. machine with a C compiler and a stdio library.  It for sure runs under
  282. Aztec C on the Amiga and on Intel '286 Multibus Xenix (don't ask why).
  283.  
  284. The documentation was significantly more work than the code.
  285.  
  286. Warm Regards,
  287. Karl @ The Alternate Hacker's Haven -- Houston, TX, 12/11/88
  288. usenet: uunet!sugar!karl  internet: karl@sugar.uu.net   bix: kelehen
  289. SHAR_EOF
  290. cat << \SHAR_EOF > app.c
  291. /* app.c - 68000 assembly pre-processor
  292.  *
  293.  * written by Karl Lehenbauer (uunet!sugar!karl or karl@sugar.uu.net) 12-8-88
  294.  * PUBLIC DOMAIN -- no warranties of usefulness, suitabilitiy, correctness
  295.  *
  296.  * There're README and make files that go along with this.  If you don't 
  297.  * have them, you've been ripped off.
  298.  */
  299.  
  300. #include <stdio.h>
  301. #include <assert.h>
  302.  
  303. #define YES 1
  304. #define NO 0
  305.  
  306. #define MATCH 0
  307.  
  308. int current_nest_level = -1;
  309. int master_label_number = 0;
  310. unsigned int line_number = 0;
  311.  
  312. char *label;
  313. char *opcode;
  314. char *operands;
  315. char *comment;
  316.  
  317. char *input_filename, *input_extension, *output_filename;
  318.  
  319. panic(s)
  320. char *s;
  321. {
  322.     fprintf(stderr,"app: %s at line %d\n",s,line_number);
  323.     fclose(stdout);
  324.     unlink(output_filename);
  325.     exit(1);
  326. }
  327.  
  328. /* given a pointer to a line, make the global character pointers "label",
  329.  * "opcode", "operands" and "comment" point to the various fields within
  330.  * the line, or NULL for any that aren't present.  Note that crackline
  331.  * butchers the line up by writing null bytes into it.
  332.  */
  333. crackline(s)
  334. register char *s;
  335. {
  336.     register char *p = s;
  337.  
  338.     label = NULL;
  339.     opcode = NULL;
  340.     operands = NULL;
  341.     comment = NULL;
  342.  
  343.     /* suck up leading blanks */
  344.     while ((*p == ' ') || (*p == '\t'))
  345.         p++;
  346.  
  347.     /* if end of line, return -- it's an empty line */
  348.     if (*p == '\0')
  349.         return;
  350.  
  351.     /* if the first nonblank char is a semicolon, it's a comment */
  352.     if (*p == ';')
  353.     {
  354.         comment = s;
  355.         return;
  356.     }
  357.  
  358.     /* if the very first char isn't blank (and we already know it's
  359.        not a semicolon), it's a label
  360.      */
  361.     if ((*s != ' ') && (*s != '\t'))
  362.     {
  363.         label = s;
  364.         p = s + 1;
  365.         while (*p != ' ' && *p != '\t' && *p != '\0') p++;
  366.         if ((*p == ' ') || (*p == '\t'))
  367.         {
  368.             *p = '\0';
  369.             p++;
  370.         }
  371.         else
  372.             return;
  373.     }
  374.     else    /* there isn't a label, suck up spaces to next parm */
  375.     {
  376.         p = s;
  377.         while ((*p == ' ' || *p == '\t')) p++;
  378.         if (*p == '\0')
  379.             return;
  380.     }
  381.  
  382.     /* if the next parm is a comment, assign and we're done */
  383.     if (*p == ';')
  384.     {
  385.         comment = p;
  386.         return;
  387.     }
  388.  
  389.     /* we're at the opcode, assign it and terminate with \0 if spaces
  390.      * follow, else we're done */
  391.     opcode = p;
  392.     while (*p != ' ' && *p != '\t' && *p != '\0') p++;
  393.     if ((*p == ' ') || (*p == '\t'))
  394.     {
  395.         *p = '\0';
  396.         p++;
  397.     }
  398.     else
  399.         return;
  400.  
  401.     /* if the next parm is a comment, assign and we're done */
  402.     if (*p == ';')
  403.     {
  404.         comment = p;
  405.         return;
  406.     }
  407.  
  408.     operands = p;
  409.     while (*p != ' ' && *p != '\t' && *p != '\0') p++;
  410.     if ((*p == ' ') || (*p == '\t'))
  411.     {
  412.         *p = '\0';
  413.         p++;
  414.     }
  415.     else
  416.         return;
  417.  
  418.     comment = p;
  419.  
  420. }
  421.  
  422. #ifdef DEBUG
  423. dumpit()
  424. {
  425.     printf("label: %s, opcode %s, operands %s, comment %s\n",label,opcode,operands,comment);
  426. }
  427. #endif
  428.  
  429. char s[255], ssave[255];
  430.  
  431. #define IF_STATEMENT_TYPE 1
  432. #define ELSE_STATEMENT_TYPE 2
  433. #define DO_STATEMENT_TYPE 3
  434.  
  435. #define MAX_NESTING_LEVELS 32
  436.  
  437. struct nesting_context
  438. {
  439.     int construct_type;
  440.     int label_number;
  441.     int second_label_number;
  442. };
  443.  
  444. struct nesting_context nesting_data[MAX_NESTING_LEVELS];
  445.  
  446. /* push - push a nesting construct context, executed on .if and .do */
  447. push(new_construct_type,label,second_label)
  448. int new_construct_type, label,second_label;
  449. {
  450.     struct nesting_context *np;
  451.  
  452.     if (++current_nest_level >= MAX_NESTING_LEVELS)
  453.         panic("too many nesting levels");
  454.  
  455.     np = &nesting_data[current_nest_level];
  456.     np->construct_type = new_construct_type;
  457.     np->label_number = label;
  458.     np->second_label_number = second_label;
  459. }
  460.  
  461. /* pop - discard the top nesting context, checking for underflow
  462.  *  called when conditionals have been successfully closed
  463.  */
  464. pop()
  465. {
  466.     if (current_nest_level >= 0)
  467.         --current_nest_level;
  468.     else
  469.         panic("'endif' or 'enddo' without a matching 'if' or 'do'");
  470. }
  471.  
  472. /* generate and return new label number */
  473. newlabel()
  474. {
  475.     return(master_label_number++);
  476. }
  477.  
  478. /* structure in support of reversing the sense of conditionals */
  479. struct condition_code_struct
  480. {
  481.     char *condition;
  482.     char *reverse_condition;
  483. };
  484.  
  485. #define N_CONDITION_TYPES 14
  486.  
  487. struct condition_code_struct condition_code_array[N_CONDITION_TYPES] =
  488. {
  489.     {"ne", "eq"},
  490.     {"eq", "ne"},
  491.     {"lt", "ge"},
  492.     {"ge", "lt"},
  493.     {"le", "gt"},
  494.     {"gt", "le"},
  495.     {"cc", "cs"},
  496.     {"cs", "cc"},
  497.     {"vc", "vs"},
  498.     {"vs", "vc"},
  499.     {"hi", "ls"},
  500.     {"ls", "hi"},
  501.     {"pl", "mi"},
  502.     {"mi", "pl"},
  503. };
  504.  
  505. /* given a pointer to text containing a condition code, returns the 
  506.  * a pointer to text containing a condition with reverse sense of
  507.  * the one passed as an argument. Bombs if the sense doesn't make sense
  508.  */
  509. char *reverse_sense_of(s)
  510. char *s;
  511. {
  512.     struct condition_code_struct *ccp;
  513.     int i;
  514.  
  515.     for (i = 0, ccp = condition_code_array; i < N_CONDITION_TYPES; i++, ccp++)
  516.  
  517.         if (strcmp(s,ccp->condition) == MATCH)
  518.             return(ccp->reverse_condition);
  519.  
  520.     panic("invalid condition code in 'if', 'elseif', 'while' or 'until'");
  521. }
  522.  
  523. /* print the label name corresponding to the number specified, should be
  524.  * called in more places in the program where printf is used instead, so
  525.  * you have to change it in several places if you want to change what the
  526.  * labels look like
  527.  */
  528. print_label(i)
  529. int i;
  530. {
  531.     printf("L%d\n",i);
  532. }
  533.  
  534. /* to prevent parsing every line, looks_promising is a quick hack to see
  535.  * if its a line we're interested in or not.  If the line doesn't have
  536.  * a period as the first non-space or tab char, it's not promising, so
  537.  * we don't crack the line with the full blown line parses.  This is a
  538.  * performance hack.
  539.  */
  540. looks_promising(s)
  541. char *s;
  542. {
  543.     while (*s != '\0')
  544.     {
  545.         if (*s == '.')
  546.             return(YES);
  547.  
  548.         if (*s != ' ' && *s != '\t')
  549.             return(NO);
  550.  
  551.         s++;
  552.     }
  553.     return(NO);
  554. }
  555.  
  556. usage()
  557. {
  558.     fprintf(stderr,"usage: app filename.app\n");
  559.     exit(1);
  560. }
  561.  
  562. main(argc,argv)
  563. int argc;
  564. char *argv[];
  565. {
  566.     fprintf(stderr,"Hackercorp public domain 68000 assembly preprocessor 0.0 12-9-88\n");
  567.  
  568.     if (argc != 2)
  569.         usage();
  570.  
  571.     input_filename = argv[1];
  572.     input_extension = input_filename + strlen(input_filename) - 4;
  573.     if (strcmp(".app",input_extension) != MATCH)
  574.         usage();
  575.  
  576.     if (freopen(input_filename,"r",stdin) == NULL)
  577.     {
  578.         perror(input_filename);
  579.         exit(5);
  580.     }
  581.  
  582.     /* kludgily create output filename */
  583.     output_filename = input_filename;
  584.     strcpy(input_extension,".asm");
  585.  
  586.     if (freopen(input_filename,"w",stdout) == NULL)
  587.     {
  588.         perror(input_filename);
  589.         exit(5);
  590.     }
  591.  
  592.     preprocess_file();
  593. }
  594.  
  595. preprocess_file()
  596. {
  597.     struct nesting_context *np;
  598.     int i;
  599.  
  600.     /* for all lines in the file */
  601.     while (gets(s) != NULL)
  602.     {
  603.         line_number++;    /* count the line */
  604.  
  605.         /* if it's not promising, copy it to output and go on */
  606.         if (!looks_promising(s))
  607.         {
  608.             printf("%s\n",s);
  609.             goto more;
  610.         }
  611.  
  612.         strcpy(ssave,s);
  613.         crackline(s);
  614.  
  615.         if (strcmp(opcode,".if") == MATCH)
  616.         {
  617.             printf("\tb%s\tL%d\n",reverse_sense_of(operands),i = newlabel());
  618.             push(IF_STATEMENT_TYPE,i,-1);
  619.         }
  620.         else if (strcmp(opcode,".else") == MATCH)
  621.         {
  622.             np = &nesting_data[current_nest_level];
  623.  
  624.             if (np->construct_type != IF_STATEMENT_TYPE)
  625.                 panic("'else' without 'if'");
  626.  
  627.             printf("\tbra\tL%d\n",i = newlabel());
  628.             /* print the label from the top context */
  629.             print_label(np->label_number);
  630.             np->label_number = i;
  631.             np->construct_type = ELSE_STATEMENT_TYPE;
  632.         }
  633.         else if (strcmp(opcode,".endif") == MATCH)
  634.         {
  635.             np = &nesting_data[current_nest_level];
  636.  
  637.             if ((np->construct_type != IF_STATEMENT_TYPE)
  638.               && (np->construct_type != ELSE_STATEMENT_TYPE))
  639.                 panic("'endif' without 'if' or 'else'");
  640.  
  641.             print_label(np->label_number);
  642.             pop();
  643.         }
  644.         else if (strcmp(opcode,".elseif") == MATCH)
  645.         {
  646.             np = &nesting_data[current_nest_level];
  647.  
  648.             if (np->construct_type != IF_STATEMENT_TYPE)
  649.                 panic("'else' without 'if'");
  650.  
  651.             printf("\tbra\tL%d\n",i = newlabel());
  652.             /* print the label from the top context */
  653.             print_label(np->label_number);
  654.             np->label_number = i;
  655.             printf("\tb%s\tL%d\n",reverse_sense_of(operands),i);
  656.         }
  657.         else if (strcmp(opcode,".do") == MATCH)
  658.         {
  659.             print_label(i = newlabel());
  660.             push(DO_STATEMENT_TYPE,i,newlabel());
  661.         }
  662.         else if (strcmp(opcode,".while") == MATCH)
  663.         {
  664.             np = &nesting_data[current_nest_level];
  665.  
  666.             if (np->construct_type != DO_STATEMENT_TYPE)
  667.                 panic("'while' without 'do'");
  668.  
  669.             printf("\tb%s\tL%d\n",reverse_sense_of(operands),np->second_label_number);
  670.         }
  671.         else if (strcmp(opcode,".enddo") == MATCH)
  672.         {
  673.             np = &nesting_data[current_nest_level];
  674.  
  675.             if (np->construct_type != DO_STATEMENT_TYPE)
  676.                 panic("'enddo' without 'do'");
  677.  
  678.             printf("\tbra\tL%d\n",np->label_number);
  679.             print_label(np->second_label_number);
  680.             pop();
  681.  
  682.         }
  683.         else if (strcmp(opcode,".until") == MATCH)
  684.         {
  685.             np = &nesting_data[current_nest_level];
  686.  
  687.             if (np->construct_type != DO_STATEMENT_TYPE)
  688.                 panic("'while' without 'do'");
  689.  
  690.             printf("\tb%s\tL%d\n",operands,np->second_label_number);
  691.         }
  692.         else
  693.             printf("%s\n",ssave);
  694.     more: ;
  695.     }
  696.     if (current_nest_level >= 0)
  697.         panic("didn't close all your control structures");
  698. }
  699. SHAR_EOF
  700. cat << \SHAR_EOF > makefile
  701. # makefile for APP assembly preprocessor
  702.  
  703. app:    app.o
  704.     ln app.o -lc
  705.  
  706. shar:    app
  707.     uuencode >app.UU app app
  708.     shar >app.shar README makefile app.c app.UU
  709. SHAR_EOF
  710. cat << \SHAR_EOF > app.uu
  711.  
  712. begin 644 app
  713. M```#\P`````````#``````````(```?I```!F`````$```/I```'Z4[Z#C!.U
  714. M50``/RR`!B\M``A(>@`P2&R!G$ZZ"]!/[P`.2&R!ADZZ&'983R\L@U).NAN2Y
  715. M6$\_/``!3KH<A%1/3EU.=6%P<#H@)7,@870@;&EN92`E9`H`3E4``$CG`#`DE
  716. M;0`()DI"K(,Z0JR#/D*L@T)"K(-&#!,`(&<&#!,`"68$4HM@\$H39@A,WPP`6
  717. M3EU.=0P3`#MF!BE*@T9@[`P2`"!G.`P2``EG,BE*@SHF2E*+#!,`(&<.#!,`I
  718. M"6<(2A-G!%*+8.P,$P`@9P8,$P`)9@9"$U*+8`)@L&`8)DH,$P`@9P8,$P`))
  719. M9@12BV#P2A-F`F"6#!,`.V8&*4N#1F"**4N#/@P3`"!G#@P3``EG"$H39P129
  720. MBV#L#!,`(&<&#!,`"68&0A-2BV`$8`#_7@P3`#MF""E+@T9@`/]0*4N#0@P3V
  721. M`"!G#@P3``EG"$H39P12BV#L#!,`(&<&#!,`"68&0A-2BV`$8`#_(BE+@T9@1
  722. M`/\:3E7__%)L@`(,;``@@`)M"DAZ`#I.NOY^6$\P+(`"P?P`!D'LA530B"M`9
  723. M__P@;?_\,*T`""!M__PQ;0`*``(@;?_\,6T`#``$3EU.=71O;R!M86YY(&YE8
  724. M<W1I;F<@;&5V96QS`$Y5``!*;(`";093;(`"8`I(>@`,3KK^&EA/3EU.=2=E8
  725. M;F1I9B<@;W(@)V5N9&1O)R!W:71H;W5T(&$@;6%T8VAI;F<@)VEF)R!O<B`GF
  726. M9&\G``!.50``,"R`!%)L@`1.74YU;F4`97$`97$`;F4`;'0`9V4`9V4`;'0`7
  727. M;&4`9W0`9W0`;&4`8V,`8W,`8W,`8V,`=F,`=G,`=G,`=F,`:&D`;',`;',`C
  728. M:&D`<&P`;6D`;6D`<&P`3E7_^D)M__I![(`(*TC__&`H(&W__"\0+RT`"$ZZ7
  729. M"7I03TI`9@P@;?_\("@`!$Y=3G52;?_Z4*W__`QM``[_^FW02'H`"DZZ_3)8H
  730. M3V#@:6YV86QI9"!C;VYD:71I;VX@8V]D92!I;B`G:68G+"`G96QS96EF)RP@J
  731. M)W=H:6QE)R!O<B`G=6YT:6PG``!.50``/RT`"$AZ``Q.NA!.7$].74YU3"5D[
  732. M"@``3E4``"!M``A*$&<N(&T`"`P0`"YF!G`!3EU.=2!M``@,$``@9PX@;0`(V
  733. M#!``"6<$<`!@Y%*M``A@RG``8-I.50``2'H`&DAL@9Q.N@AL4$\_/``!3KH9G
  734. M-E1/3EU.=75S86=E.B!A<'`@9FEL96YA;64N87!P"@``3E4``$AZ`+Y(;(&<%
  735. M3KH(,E!/#&T``@`(9P)AJB!M``HI:``$@THO+(-*3KH%>EA/2,#0K(-*68`IZ
  736. M0(-.+RR#3DAZ`,1.N@@R4$]*0&<$3KK_=DAL@7!(>@"S+RR#2DZZ!P9/[P`,W
  737. M2D!F%"\L@TI.N@=N6$\_/``%3KH8FE1/*6R#2H-22'H`AR\L@TY.N@4(4$](5
  738. M;(&&2'H`>B\L@TI.N@;&3^\`#$I`9A0O+(-*3KH'+EA//SP`!4ZZ&%I43V%47
  739. M3EU.=4AA8VME<F-O<G`@<'5B;&EC(&1O;6%I;B`V.#`P,"!A<W-E;6)L>2!P5
  740. M<F5P<F]C97-S;W(@,"XP(#$R+3DM.#@*`"YA<'``<@`N87-M`'<`3E7_^DAL,
  741. M@U9.N@2:6$]*0&<``RQ2;(`&2&R#5DZZ_E983TI`9A)(;(-62'H#)DZZ#H10^
  742. M3V```P1(;(-62&R$54ZZ!$!03TAL@U9.NOM,6$](>@,$+RR#/DZZ!PI03TI`E
  743. M9CA.NOT$.T#_^C\`+RR#0DZZ_5I83R\`2'H"X$ZZ#C9/[P`*/SS__S\M__H_$
  744. M/``!3KK\(%Q/8``"HDAZ`L@O+(,^3KH&P%!/2D!F7C`L@`+!_``&0>R%5-"(R
  745. M*T#__"!M__P,4``!9PI(>@*@3KKZ>%A/3KK\E#M`__H_`$AZ`J!.N@W27$\@B
  746. M;?_\/R@``DZZ_6A43R!M__PQ;?_Z``(@;?_\,+P``F```C)(>@)\+RR#/DZZP
  747. M!E!03TI`9D8P+(`"P?P`!D'LA530B"M`__P@;?_\#%```6<4(&W__`Q0``)G]
  748. M"DAZ`DM.NOG^6$\@;?_\/R@``DZZ_0)43TZZ^[I@``':2'H"2B\L@SY.N@7X!
  749. M4$]*0&9R,"R``L'\``9![(54T(@K0/_\(&W__`Q0``%G"DAZ`B1.NOFP6$].*
  750. MNOO,.T#_^C\`2'H")$ZZ#0I<3R!M__P_*``"3KK\H%1/(&W__#%M__H``C\MK
  751. M__HO+(-"3KK[_%A/+P!(>@'\3KH,V$_O``I@``%62'H!]B\L@SY.N@5T4$]*7
  752. M0&8H3KK[;CM`__H_`$ZZ_%143TZZ^UX_`#\M__H_/``#3KKZFEQ/8``!'$AZV
  753. M`<`O+(,^3KH%.E!/2D!F2C`L@`+!_``&0>R%5-"(*T#__"!M__P,4``#9PI("
  754. M>@&93KKX\EA/(&W__#\H``0O+(-"3KK[9EA/+P!(>@&03KH,0D_O``I@``#`0
  755. M2'H!BB\L@SY.N@3>4$]*0&9,,"R``L'\``9![(54T(@K0/_\(&W__`Q0``-GA
  756. M"DAZ`6-.NOB66$\@;?_\/R@``DAZ`69.N@OR7$\@;?_\/R@`!$ZZ^XA43TZZ@
  757. M^D!@8$AZ`5(O+(,^3KH$@%!/2D!F0#`L@`+!_``&0>R%5-"(*T#__"!M__P,_
  758. M4``#9PI(>@$K3KKX.%A/(&W__#\H``0O+(-"2'H!*DZZ"Y!/[P`*8`Y(;(15W
  759. M2'H!(DZZ"WY03V``_,A*;(`";0I(>@$23KKW_%A/3EU.=25S"@`N:68`"6(E\
  760. M<PE,)60*`"YE;'-E`"=E;'-E)R!W:71H;W5T("=I9B<`"6)R80E,)60*`"YE3
  761. M;F1I9@`G96YD:68G('=I=&AO=70@)VEF)R!O<B`G96QS92<`+F5L<V5I9@`G+
  762. M96QS92<@=VET:&]U="`G:68G``EB<F$)3"5D"@`)8B5S"4PE9`H`+F1O`"YWX
  763. M:&EL90`G=VAI;&4G('=I=&AO=70@)V1O)P`)8B5S"4PE9`H`+F5N9&1O`"=EM
  764. M;F1D;R<@=VET:&]U="`G9&\G``EB<F$)3"5D"@`N=6YT:6P`)W=H:6QE)R!W_
  765. M:71H;W5T("=D;R<`"6(E<PE,)60*`"5S"@!D:61N)W0@8VQO<V4@86QL('EO\
  766. M=7(@8V]N=')O;"!S=')U8W1U<F5S```@;P`$(`@B;P`($-EF_$YU(&\`!"`(I
  767. M2AAF_)'`(`A3@$YU3E4``$CG""`D;0`(3KH`-C@`L'S__V<.N'P`"F<(($I2D
  768. MBA"$8.9"$KA\__]F$+7M``AF"G``3-\$$$Y=3G4@+0`(8/).50``2&R!<$ZZ.
  769. M``A83TY=3G5.50``2.<(("1M``@O"DZZ`#(X`+!\__]83V<B,`1(P&`44Y((2
  770. MZ@`#``QP_TS?!!!.74YU8-9*@&?Z68!GY#`$8.I.50``+PHD;0`((%*QZ@`$>
  771. M90PO"F$66$\D7TY=3G4@4E*2$!!(@,!\`/]@[$Y5``!(YP@P)&T`"!`J``S`G
  772. M/``89PIP_TS?#!!.74YU"*H``@`,2JH`"&8(+PI.N@_D6$\0*@`,2(`(```'+
  773. M9S!![(%P)D@0*P`,2(#`?`"$L'P`A&8,/SS__R\+3KH.G%Q/U_P````60>R#]
  774. M*+?(9=8_*@`0+RH`"!`J``U(@#\`3KH#"#@`2D!03VX42D1F!'`(8`)P$($J]
  775. M``QP_V``_WHP!$C`)*H`"-"J``@E0``$(%)2DA`02(#`?`#_8`#_6DY5```O5
  776. M"DZZ#Q0D0$J`9@AP`"1?3EU.=2\*+RT`#"\M``AA!D_O``Q@Z$Y5``!(YP@@J
  777. M+RT`$$ZZ#7Y![(!X)$A83TH29A`Y?``%AA1P`$S?!!!.74YU($HB;0`,$!BP7
  778. M&68$2@!F]I`A2(!G!%R*8-(_*@`$+RT`"$ZZ`0HX`+!\__]<3V8$<`!@Q"!MA
  779. M`!`11``-(&T`$!%\``$`#"`M`!!@K$Y5``!*;(84;0HP+(84L&R`VF\&</].:
  780. M74YU2JT`"&<4+RT`"$AZ`#)(;(&<3KH`-$_O``PP+(842,#E@$'L@*XO,`@`N
  781. M2'H`%TAL@9Q.N@`4<`!/[P`,8+XE<SH@`"5S"@``3E4``"EM``B#,DAM`!`O<
  782. M+0`,2'H`#DZZ"!I/[P`,3EU.=4Y5```O+(,R/RT`"$ZZ"]Q<3TY=3G4P/'__$
  783. M8`0P+P`,4T!K%"!O``0B;P`(L0EF#%-(2AA7R/_V<`!.=6,$<`%.=7#_3G5.8
  784. M50``/RT`##\\`P$O+0`(80903TY=3G5.50``2.</,"1M``A.N@_L)FR&%G@`W
  785. M8`XP!,'\``9*LP@`9PY21+AL@RAM['H&8```Q`@M``$`#&<P2'C__R\*3KH1J
  786. MV"P`4$]G("\&3KH2$"\*3KH1GDJ`4$]F#DZZ$:@Z`+!\`,UF``",2'@#[2\*E
  787. M3KH1MBP`2H903V9@""T````,9@1Z`6!L2'@#[B\*3KH1F"P`4$]F"$ZZ$6PZU
  788. M`&!42'@`(4AZ`)).NA(T+@!03V<*+P=.NA'>6$]@'DAX``%(>@""+P9.NA&B\
  789. M2'C__T*G+P9.NA%X3^\`&&`F,"T`#,!\!0"P?`4`9A@O!DZZ$.QZ!%A/.46&$
  790. M%'#_3-\,\$Y=3G4P!,'\``8GA@@`,`3!_``&($#1RS%M``P`!`@M``,`#&<0@
  791. M2'@``4*G+P9.NA$>3^\`##`$8,)D;W,N;&EB<F%R>0```$Y5``!(YPP@."T`"
  792. M"$ZZ#J8P!,'\``8D0-7LAA9*1&T*N&R#*&P$2I)F$#E\``*&%'#_3-\$,$Y=<
  793. M3G4P*@`$P'P``[!\``%F"CE\``6&%'#_8.!P`#`M``XO`"\M``HO$DZZ$)8J)
  794. M`+"\_____T_O``QF#$ZZ$$PY0(84</]@M"`%8+!A<$/L@S)%[(,RM<EF#C(\.
  795. M`,MK"'0`(L)1R?_\*4^&&BQX``0I3H8>2.>`@`@N``0!*6<02_H`"$ZN_^)@:
  796. M!D*G\U].<T/Z`"!.KOYH*4"&(F8,+CP``X`'3J[_E&`$3KH`&E!/3G5D;W,NC
  797. M;&EB<F%R>0!)^0``?_Y.=4Y5```O"DAY``$``#`L@RC!_``&+P!.NA!&*4"&;
  798. M%E!/9A1"ITAY``$``$ZZ$`I03RYLAAI.=2!LAA9":``$(&R&%C%\``$`$"!L@
  799. MAA8Q?``!``H@;(8:("R&&I"H``10@"E`AB8@;(8F(+Q-04Y80J=.N@_Z)$!*]
  800. MJ@"L6$]G+B\M``PO+0`(+PI.N@"N.7P``88J(&R&%@!H@```!"!LAA8`:(``7
  801. M``I/[P`,8$)(:@!<3KH0%$AJ`%Q.N@_6*4"&+"!LABQ*J``D4$]G$"!LABPB0
  802. M:``D+Q%.N@[,6$\O+(8L+PI.N@,N*6R&+(8P4$].N@[,(&R&%B"`3KH.^B!LV
  803. MAA8A0``&9Q9(>`/M2'H`*DZZ#M8@;(86(4``#%!/+RR&,#\LAC1.NO/80F=.\
  804. MN@SF4$\D7TY=3G4J`$Y5``!(YPPP)&T`$"!M``A*J`"L9Q@@;0`(("@`K.6`U
  805. M*``@1"`H`!#E@"9`8`0F;(,J$!-(@$C`T*T`#%2`.4"&-D*G,"R&-DC`+P!.=
  806. MN@[8*4"&.%!/9@A,WPPP3EU.=1`32(`Z`#\%($M2B"\(+RR&.$ZZ`7XP!4C`K
  807. M($#1[(8X0_H!1!#99OP_+0`.+PHO+(8X3KH!.B!LACA",%``.7P``88T,`5(P
  808. MP-"LAC@F0%*+)$M/[P`4$!-(@#H`L'P`(&<8NGP`"6<2NGP`#&<,NGP`#6<&+
  809. MNGP`"F8$4HM@V`P3`"!M>@P3`")F+E*+($M2BQ`02(`Z`&<>($I2BA"%NGP`7
  810. M(F80#!,`(F8$4HM@!D(J__]@`F#68#@@2U*+$!!(@#H`9R:Z?``@9R"Z?``)S
  811. M9QJZ?``,9Q2Z?``-9PZZ?``*9P@@2E**$(5@SB!*4HI"$$I%9@)3BU)LAC1@S
  812. M`/]:0A)"IS`LAC120$C`Y8`O`$ZZ#;8I0(8P4$]F"$)LAC1@`/[8>@`F;(8XY
  813. M8"0P!4C`Y8`@;(8P(8L(`"!+(`A*&&;\D<!3B#`(4D!(P-?`4D6Z;(8T;=8PR
  814. M!4C`Y8`@;(8P0K`(`&``_I0@`#`\?_]@!#`O``P@;P`$2AAF_%-((F\`"%-`7
  815. M$-E7R/_\9P)"$"`O``1.=4SO`P``!"`(,B\`#&`"$-E7R?_\9P9206`"0AA1>
  816. MR?_\3G5.;R!E<G)O<@!&:6QE(&YO="!F;W5N9`!"860@9FEL92!H86YD;&4`.
  817. M26YS=69F:6-I96YT(&UE;6]R>0!&:6QE(&5X:7-T<P!);G9A;&ED(&9U;F-TG
  818. M:6]N(&YU;6)E<@!4;V\@;6%N>2!O<&5N(&9I;&5S`$YO="!A(&-O;G-O;&4@@
  819. M9&5V:6-E`$EN=F%L:60@86-C97-S(&-O9&4`4F5S=6QT('1O;R!L87)G90!!A
  820. M<F=U;65N="!O=70@;V8@9&]M86EN``!.50``2.<.,"1M``A"ITAZ`(Y.N@QVS
  821. M*4"&/%!/9@A,WPQP3EU.=2!M``PB:``D+RD`!$ZZ#*8H`%A/9U)(>@!M($0OT
  822. M*``V3KH,>"9`2H!03V<T2'@#[2\+3KH+>BP`4$]G)"`&Y8`J`"!%)6@`"`"DT
  823. M)48`G$AX`^U(>@`X3KH+5B5``*!03R\$3KH,1%A/+RR&/$ZZ"ZA"K(8\6$]@_
  824. M@&EC;VXN;&EB<F%R>0!724Y$3U<`*@!.50``2&T`#"\M``A(>@1@3KH`F$_O:
  825. M``Q.74YU3E4``$CG""`D;0`.#&T`!``29@@@;0`(*!!@'$IM``QO#"!M``AP<
  826. M`#`0*`!@"B!M``@P$$C`*`!";0`22FT`#&P01&T`#$J$;`A$A#M\``$`$C(M'
  827. M``Q(P2`$3KH#D$'L@-Q3BA2P```R+0`,2,$@!$ZZ`X8H`&;:2FT`$F<&4XH4V
  828. MO``M(`I,WP003EU.=4Y5_R)(YP@P)&T`""9M``Q";?_Z*VT`$/_\($M2BQ`06
  829. M2(`X`&<``NZX?``E9@`"S$(M_S`[?``!__@[?``@__8[?"<0__0@2U*+$!!(.
  830. M@#@`L'P`+68.0FW_^"!+4HL0$$B`.`"X?``P9A`[?``P__8@2U*+$!!(@#@`Q
  831. MN'P`*F88(&W__%2M__P[4/_R($M2BQ`02(`X`&`R0FW_\F`<,"W_\L'\``K07
  832. M1)!\`#`[0/_R($M2BQ`02(`X`#`$4D!![(#N"#```@``9M2X?``N9EH@2U*+3
  833. M$!!(@#@`L'P`*F88(&W__%2M__P[4/_T($M2BQ`02(`X`&`R0FW_]&`<,"W_J
  834. M],'\``K01)!\`#`[0/_T($M2BQ`02(`X`#`$4D!![(#N"#```@``9M0[?``"O
  835. M__"X?`!L9A(@2U*+$!!(@#@`.WP`!/_P8!"X?`!H9@H@2U*+$!!(@#@`,`1(Y
  836. MP&!Z.WP`"/_N8!8[?``*_^Y@#CM\`!#_[F`&.WS_]O_N/RW_\$AM_S`_+?_NC
  837. M+RW__$ZZ_>0K0/_J,"W_\$C`T:W__$_O``Q@7"!M__Q8K?_\(E`K2?_J(`E*Q
  838. M&6;\D\!3B3M)__!@2B!M__Q4K?_\.!!![?\O*TC_ZA"$8"B0O````&-GXE.`R
  839. M9Y*0O`````MG`/]R68!GLE6`9P#_<%>`9P#_<F#,0>W_,)'M_^H[2/_P,"W_R
  840. M\+!M__1O!CMM__3_\$IM__AG:"!M_^H,$``M9PH@;?_J#!``*V8N#&T`,/_V;
  841. M9B93;?_R(&W_ZE*M_^H0$$B`/P!.DK!\__]43V8*</],WPP03EU.=6`6/RW_D
  842. M]DZ2L'S__U1/9@1P_V#D4FW_^C`M__)3;?_RL&W_\&[<0FW_[F`@(&W_ZE*M>
  843. M_^H0$$B`/P!.DK!\__]43V8$</]@L%)M_^X@;?_J2A!G"C`M_^ZP;?_T;<XP8
  844. M+?_NT6W_^DIM__AF*&`8/SP`($Z2L'S__U1/9@9P_V``_WA2;?_Z,"W_\E-M%
  845. M__*P;?_P;MI@%C\$3I*P?/__5$]F!G#_8`#_4E)M__I@`/T(,"W_^F``_T)(3
  846. MYT@`0H1*@&H$1(!21$J!:@9$@0I$``%A/DI$9P)$@$S?`!)*@$YU2.=(`$*$W
  847. M2H!J!$2`4D1*@6H"1(%A&B`!8-@O`6$2(`$B'TJ`3G4O`6$&(A]*@$YU2.<PX
  848. M`$A!2D%F($A!-@$T`$)`2$"`PR(`2$`R`H+#,`%"04A!3-\`#$YU2$$F`2(`'
  849. M0D%(04A`0D!T#]"`TX&V@6($DH-20%'*__),WP`,3G5.50``2&R!AC\M``A.G
  850. MN@`(7$].74YU3E4``"\$."T`""\M``H_!$ZZ`#"X?``*7$]F)"!M``H0*``,-
  851. M2(`(```'9Q0_//__+RT`"DZZ`/1<3R@?3EU.=6#X3E4``"\*)&T`"B!2L>H`I
  852. M!&48,"T`",!\`/\_`"\*3KH`R%Q/)%].74YU(%)2DA`M``D0@$B`P'P`_V#H\
  853. M3E4``"\*0>R!<"1(($K5_````!8O"&$06$]![(,HM<AEZB1?3EU.=4Y5``!(&
  854. MYP@@)&T`"'@`(`IF"G#_3-\$$$Y=3G5**@`,9U`(*@`"``QG##\\__\O"F%2E
  855. M.`!<3Q`J``U(@#\`3KH%'(A`""H``0`,5$]G"B\J``A.N@(N6$\(*@`%``QG?
  856. M$B\J`!).N@+`+RH`$DZZ`A103T*20JH`!$*J``A"*@`,,`1@D$Y5__Y(YP@@Z
  857. M)&T`"$'Z_T8I2(9`""H`!``,9PIP_TS?!!!.74YU""H``@`,9S`@4I'J``@XC
  858. M"#\$+RH`"!`J``U(@#\`3KH"@+!$4$]G$`CJ``0`#$*20JH`!'#_8,`,;?__:
  859. M``QF$`BJ``(`#$*20JH`!'``8*A*J@`(9@@O"DZZ`)I83PQJ``$`$&8J&VT`)
  860. M#?__/SP``4AM__\0*@`-2(`_`$ZZ`B*P?``!4$]FH#`M``Q@`/]J)*H`"#`JH
  861. M`!!(P-"J``@E0``$".H``@`,(%)2DA`M``T0@$B`P'P`_V``_SY.50``+PI!P
  862. M[(%P)$A**@`,9QC5_````!9![(,HM<AE"'``)%].74YU8.)"DD*J``1"J@`(,
  863. M(`I@ZDY5__PO"B1M``@_/`0`3KH`P"M`__Q43V88-7P``0`0($K1_`````XE>
  864. M2``()%].74YU-7P$```0".H``0`,)6W__``($"H`#4B`/P!.N@#B2D!43V<&L
  865. M`"H`@``,8,Y.50``2.<`,"1L@S9@%"92("H`!%"`+P`O"DZZ!'A03R1+(`IF#
  866. MZ$*L@S9,WPP`3EU.=4Y5```O"D'Z_\8I2(9$0J<@+0`(4(`O`$ZZ!"8D0$J`H
  867. M4$]F"'``)%].74YU)*R#-B5M``@`!"E*@S8@"E"`8.9.50``<``P+0`(+P!A)
  868. MLEA/3EU.=4Y5``!(YP`PE\LD;(,V8`X@;0`(48BQRF<2)DHD4B`*9NYP_TS?"
  869. M#`!.74YU(`MG!":28`0I4H,V("H`!%"`+P`O"DZZ`\IP`%!/8-A.50``+PHP.
  870. M+0`(P?P`!B1`U>R&%DIM``AM#C`M``BP;(,H;`1*DF8..7P``H84</\D7TY=-
  871. M3G4P+0`(P?P`!B!LAA8O,`@`3KH"QDJ`6$]G!'`!8`)P`SE4``"\M``A.V
  872. MN@*02H!83V8.3KH"FCE`AA1P_TY=3G5P`Ϥ``$CG#"`X+0`(3KH`<#`$D
  873. MP?P`!B1`U>R&%DI$;0JX;(,H;`1*DF80.7P``H84</],WP0P3EU.=3`J``3`%
  874. M?``#9@HY?``%AA1P_V#D<``P+0`.+P`O+0`*+Q).N@*0*@"PO/____]/[P`,=
  875. M9@Q.N@(:.4"&%'#_8+@@!6"T3E7__$AX$`!"ITZZ`O0K0/_\"```#%!/9Q)*:
  876. M;(8J9@@@+?_\3EU.=4ZZ``9P`&#T3E4``$AX``1(>@`<3KH!_B\`3KH"+#\\^
  877. M``%.N@`.3^\`#DY=3G5>0PH`3E4``$JLAD!G!B!LAD!.D#\M``A.N@`(5$].M
  878. M74YU3E7__"\$,"T`"$C`*T#__$JLAA9G*'@`8`H_!$ZZ`/Y43U)$N&R#*&WPU
  879. M,"R#*,'\``8O`"\LAA9.N@(64$]*K(9$9P8@;(9$3I!*K(,N9PHO+(,N3KH!]
  880. MDEA/2JR&2&<((&R&2""LADQ*K(909PHO+(903KH!KEA/2JR&5&<*+RR&5$ZZN
  881. M`9Y83TJLAEAG"B\LAEA.N@&.6$]*K(9<9PHO+(9<3KH!?EA/+'@`!`@N``0!9
  882. M*6<4+PU+^@`*3J[_XBI?8`9"I_-?3G-*K(8L9C!*K(8X9R@P+(8V2,`O`"\LB
  883. MACA.N@%N,"R&-%)`2,#E@"\`+RR&,$ZZ`5I/[P`08`Y.N@%(+RR&+$ZZ`718<
  884. M3R`M__PN;(8:3G4H'TY=3G5.50``2.<.(#@M``@P!,'\``8D0-7LAA9*1&T*S
  885. MN&R#*&P$2I)F$#E\``*&%'#_3-\$<$Y=3G4(*@`'``1F""\23KH`"EA/0I)P'
  886. M`&#B(B\`!"QLAB).[O_<(B\`!"QLAB).[O^"(B\`!"QLAB).[O^X+&R&(D[N$
  887. M_\HL;(8B3N[_?"(O``0L;(8B3N[_*$SO``8`!"QLAB).[O^L3.\`!@`$+&R&'
  888. M(D[N_^(L;(8B3N[_Q$SO``X`!"QLAB).[O_63.\`#@`$+&R&(D[N_[Y.^@`"L
  889. M(B\`!"QLAB).[O^F3.\`#@`$+&R&(D[N_]!(YP$$3.\@@``,+&R&'DZN_Y1,`
  890. MWR"`3G5.^@`"(F\`!"QLAAY.[OYB3.\``P`$+&R&'D[N_SHB;P`$+&R&'D[NY
  891. M_MHL;(8>3N[_?")O``0@+P`(+&R&'D[N_RX@;P`$+&R&'D[N_HPL;(8>(F\`^
  892. M!"`O``A.[OW8(F\`!"QLAAY.[OZ&3.\``P`$+&R&'D[N_LX@;P`$+&R&'D[N.
  893. M_H!,[P,```0L;(8\3N[_H"!O``0L;(8\3N[_IB!O``0L;(8\3N[_L@```^P`,
  894. M```!`````0``#J8````````#\@```^H```#,__\````````"-@```CD```(\3
  895. M```"/P```D(```)%```"2````DL```).```"40```E0```)7```"6@```ET`P
  896. M``)@```"8P```F8```)I```";````F\```)R```"=0```G@```)[```"?@``;
  897. M`H$```*$```"AW(``````'(K`````G<````#`7<K```#`F$````)`6$K```)%
  898. M`G@````%`7@K```%`@``````````$?@``!(!```2$```$B```!(T```20```R
  899. M$E@``!)L```2@0``$I4``!*F``LP,3(S-#4V-S@Y86)C9&5F````("`@("`@'
  900. M("`@,#`P,#`@("`@("`@("`@("`@("`@(""00$!`0$!`0$!`0$!`0$!`#`P,$
  901. M#`P,#`P,#$!`0$!`0$`)"0D)"0D!`0$!`0$!`0$!`0$!`0$!`0$!`4!`0$!`>
  902. M0`H*"@H*"@("`@("`@("`@("`@("`@("`@("0$!`0"``````````````````$
  903. M`0`````!``````````````````````$!`````0`````````````````````!&
  904. M`@````$`````````````````````````````````````````````````````#
  905. M`````````````````````````````````````````````````````````````
  906. M`````````````````````````````````````````````````````````````
  907. M`````````````````````````````````````````````````````````````
  908. M`````````````````````````````````````````````````````````````
  909. M`````````````````````````````````````````````````````````````
  910. M`````````````````````````````````````````````````````````````
  911. M`````````````````````````````````````````````````````````````
  912. M````````````````````````````````%``````````````#[````"<`````J
  913. M````!@````H````.````$@```!8````:````'@```"(````F````*@```"X`>
  914. M```R````-@```#H````^````0@```$8```!*````3@```%(```!6````6@``"
  915. M`%X```!B````9@```&H```!N````<@```*P```"P````M````+@```"\````T
  916. IP````,0```#(````S````-````#4`````````_(```/K`````0```_*\1
  917. ``
  918. end
  919. size 9176
  920. SHAR_EOF
  921. #    End of shell archive
  922. exit 0
  923. -- 
  924. Bob Page, U of Lowell CS Dept.  page@swan.ulowell.edu  ulowell!page
  925. Have five nice days.
  926.